home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 010a / dietdisc.zip / FATTEN.C < prev    next >
C/C++ Source or Header  |  1991-02-10  |  9KB  |  376 lines
  1.  
  2. #define  BUFSIZE 32000
  3. #define  MAXFILES  400
  4. #define  TRIES      16
  5. #define  DELAY       2
  6. #define  TRUE        1
  7. #define  FALSE       0
  8.  
  9. #include <stdio.h>
  10. #include <dos.h>
  11. #include <io.h>
  12. #include <string.h>
  13. #include <fcntl.h>
  14. #include <dir.h>
  15. #include <process.h>
  16. #include <stdlib.h>
  17. #include <alloc.h>
  18. #include <mem.h>
  19.  
  20. extern  unsigned char   _osmajor;
  21.  
  22. void    fattenfile(char *);
  23. void    getbuffer(void);
  24. char    *filefind(void);
  25. int     int24handler(int, int, int, int);
  26. int     isnet(void);
  27.  
  28. /***************************************************************/
  29.  
  30. int     fhin, fhout;
  31. char    *buffer;
  32. int     bytecount;
  33.  
  34. double  oldsize, newsize;
  35. double  skinny_pct;
  36.  
  37. char    *filename_ptr;
  38. char    msg[25];
  39. char    *footprint;
  40. char    *filepattern;
  41. char    foottest[80];
  42.  
  43. struct  ffblk   dos_find_blk;
  44.  
  45. char    *filename_array;
  46. char    *name_ptrs[MAXFILES];
  47.  
  48. char    drive[MAXDRIVE];
  49. char    dirs[MAXDIR];
  50. char    filename[MAXFILE];
  51. char    ext[MAXEXT];
  52. int     name_flag;
  53.  
  54. int     count, error, mode, fileattrib, driveno;
  55. int     network, exists;
  56. int     numfiles;
  57. int     firsttime;
  58.  
  59. char    drive[MAXDRIVE];
  60. char    dirs[MAXDIR];
  61. char    filename[MAXFILE];
  62. char    ext[MAXEXT];
  63. int     name_flag;
  64.  
  65. int     i, j, k;
  66. int     argcx, argdx;
  67. long    filetime;
  68.  
  69. char far    *mydta;
  70. char far    *olddta;
  71. unsigned    useg;
  72. unsigned    int our_cs;
  73.  
  74. /***************************************************************/
  75.  
  76. void    main (argc, argv, envp)
  77.                 int     argc;
  78.                 char    *argv[];
  79.                 char    *envp[];
  80.  
  81.         {
  82.         harderr(int24handler);
  83.  
  84.         count = 0;
  85.  
  86.         _AX = 0x3341;
  87.         geninterrupt(0x21);
  88.         if (_DX == 0x1234)
  89.             goto loaded_ok;
  90.  
  91.         printf("\n\nPlease run Diet Disk before trying to fatten files.\n\n");
  92.         exit(1);
  93.  
  94.  
  95. loaded_ok:
  96.         if (argc != 2)
  97.            {
  98.            printf("\n\nUsage: FATTEN <filename>.  Wildcards are * and ?.\n\n");
  99.            exit(0);
  100.            }
  101.  
  102.         name_flag = fnsplit(argv[1], drive, dirs, filename, ext);
  103.         filepattern = argv[1];
  104.  
  105.         if (_osmajor < 2)
  106.            {
  107.            printf("\n\nIncorrect DOS version.\n\n");
  108.            goto bail_out;
  109.            }
  110.  
  111.         if ((buffer = (char *) malloc(BUFSIZE)) == NULL)
  112.            {
  113.            printf("\n\nInsufficient memory.\n\n");
  114.            goto bail_out;
  115.            }
  116.  
  117.         if ((filename_array = (char *) calloc(MAXFILES, 14)) == NULL)
  118.            {
  119.            printf("\n\nInsufficient memory.\n\n");
  120.            goto bail_out;
  121.            }
  122.  
  123.  
  124.         if ((mydta = (char *) malloc(128)) == NULL)
  125.            {
  126.            printf("\n\nInsufficient memory.\n\n");
  127.            goto bail_out;
  128.            }
  129.  
  130.  
  131.         _fmode  = O_BINARY;
  132.         error   = 0;
  133.         mode    = O_RDONLY;
  134.         network = 0;
  135.  
  136.         if (isnet())
  137.            {
  138.            network = 1;
  139.            mode    = O_RDONLY | O_DENYNONE;
  140.            argdx   = TRIES;
  141.            argcx   = DELAY;
  142.            ioctl (0, 11, argdx, argcx);
  143.            }
  144.  
  145.         numfiles = 0;
  146.         bytecount = 0;
  147.  
  148.         while ( (filename_ptr = filefind()) != NULL)
  149.             {
  150.             name_ptrs[numfiles] = filename_array + bytecount;
  151.             movmem(filename_ptr,  filename_array + bytecount,
  152.                         strlen(filename_ptr)+1);
  153.             bytecount += (strlen(filename_ptr)+1);
  154.             numfiles++;
  155.             if (numfiles > (MAXFILES - 5))
  156.                 {
  157.                 printf("\nToo many files (max is 400).\n");
  158.                 printf("Change your wildcards to fatten fewer files at a time.\n");
  159.                 goto bail_out;
  160.                 }
  161.             }
  162.  
  163.         if (numfiles == 0)
  164.            {
  165.            printf("\nFile(s) not found.\n");
  166.            goto bail_out;
  167.            }
  168.  
  169.         printf("Fattening files....\n\n");
  170.  
  171.         for (i = 0; i < numfiles; i++)
  172.             fattenfile(name_ptrs[i]);
  173.         
  174.  
  175. normal_exit:
  176.         printf("\n%d file(s) fattened.\n", count);
  177.  
  178.         if (error)
  179.             {
  180.             printf("Fatten ended.  Some errors occurred.\n");
  181.             exit(1);
  182.             }
  183.  
  184.         printf("\n\nFatten ended successfully.\n");
  185.         exit(0);
  186.  
  187.  
  188. bail_out:
  189.         fcloseall();
  190.         printf("\n%d file(s) fattened.\n", count);
  191.         printf("Fatten ended due to error.\n");
  192.         exit(1);
  193.         }
  194.  
  195. /***************************************************************/
  196.  
  197. void    fattenfile(char *cptr)
  198.  
  199.         {
  200.         char    iptr[MAXPATH];
  201.         char    optr[MAXPATH];
  202.         struct  ftime ftimestruc;
  203.         char    fullname[MAXPATH];
  204.  
  205.  
  206.         strcpy(iptr, cptr);
  207.         strupr(iptr);
  208.         printf("  %-14s ", iptr);
  209.  
  210.         fnmerge(fullname, drive, dirs, iptr, NULL);
  211.         strcpy(iptr, fullname);
  212.         fnmerge(optr, drive, dirs, "TEMP", ".FAT");
  213.  
  214.         if (strstr("TEMP.FAT", iptr) != NULL)
  215.            {
  216.            printf("\nInvalid file name!\n");
  217.            error = 1;
  218.            return;
  219.            }
  220.  
  221.         if (strstr(optr, iptr) != NULL)
  222.            {
  223.            printf("\nInvalid file name!\n");
  224.            error = 1;
  225.            return;
  226.            }
  227.  
  228.         if ((fhin = _open(iptr, mode)) == -1)
  229.            {
  230.            printf("\nInternal error; file not found.\n");
  231.            exit(1);
  232.            }
  233.  
  234.         if ((fhout = _creat(optr, 0)) == -1)
  235.            {
  236.            printf("\nInternal error--file creation.\n");
  237.            exit(1);
  238.            }
  239.  
  240.         getbuffer();
  241.         while (bytecount > 0)
  242.               {
  243.               if ((_write(fhout, buffer, bytecount)) != bytecount)
  244.                  {
  245.                  printf("\nError writing file.");
  246.                  printf("\nFatten operation terminated.\n");
  247.                  remove (optr);
  248.                  exit(1);
  249.                  }
  250.  
  251.               if (bytecount < BUFSIZE)
  252.                  break;
  253.  
  254.               getbuffer();
  255.               }
  256.  
  257.         getftime(fhin, &ftimestruc);
  258.         setftime(fhout,&ftimestruc);
  259.  
  260.         _close (fhin);
  261.         _close (fhout);
  262.  
  263.         findfirst(iptr, (struct ffblk *) &dos_find_blk, 0);
  264.         oldsize   = dos_find_blk.ff_fsize * 1.0;
  265.  
  266.         findfirst(optr, (struct ffblk *) &dos_find_blk, 0);
  267.         newsize   = dos_find_blk.ff_fsize * 1.0;
  268.  
  269.         if (oldsize != newsize)
  270.             {
  271.             printf ("old size = %10.0lf  new size = %10.0lf  ", oldsize, newsize);
  272.             if (newsize == 0.0)
  273.                skinny_pct = 0.0;
  274.             else
  275.                skinny_pct = ((newsize - oldsize) / newsize) * 100.0;
  276.             printf(" (% 4.0lf%%)\n", skinny_pct);
  277.             remove (iptr);
  278.             rename (optr, iptr);
  279.             count++;
  280.             }
  281.         else
  282.             {
  283.             printf (" ...was already fat.\n");
  284.             remove (iptr);
  285.             rename (optr, iptr);
  286.             }
  287.         }
  288.  
  289. /***************************************************************/
  290.  
  291. void    getbuffer()
  292.  
  293.         {
  294.         if ((bytecount = _read(fhin, buffer, BUFSIZE)) == -1)
  295.            {
  296.            printf("\nError reading file.");
  297.            printf("\nFatten operation terminated.\n");
  298.            exit(1);
  299.            }
  300.         }
  301.  
  302. /***************************************************************/
  303.  
  304. char    *filefind()
  305.         {
  306.  
  307.         olddta = getdta();
  308.  
  309.         if (firsttime) goto getnextblk;
  310.  
  311.         firsttime = 1;
  312.         if (findfirst(filepattern, (struct ffblk *) &dos_find_blk, 0) != 0)
  313.            {
  314.             setdta( (char far *) &olddta);
  315.             return(NULL);
  316.            }
  317.  
  318.         setdta( (char far *) &olddta);
  319.         return(dos_find_blk.ff_name);
  320.  
  321. getnextblk:
  322.         if (findnext( (struct ffblk *) &dos_find_blk) != 0)
  323.            {
  324.             setdta( (char far *) &olddta);
  325.             return(NULL);
  326.            }
  327.  
  328.         setdta( (char far *) &olddta);
  329.         return(dos_find_blk.ff_name);
  330.  
  331.         }
  332.  
  333. /***************************************************************/
  334.  
  335. int     isnet()
  336.         {
  337.         union REGS      regs;
  338.  
  339.         if (_osmajor > 2 && _osminor > 0)
  340.             for (i=3; i<21; i++)
  341.                 {
  342.                 regs.x.ax = 0x4409;
  343.                 regs.x.bx = i;
  344.                 int86(0x21, ®s, ®s);
  345.                 if ( (regs.x.dx & 0x1000) == 0x1000 )
  346.                     return(TRUE);
  347.                 }
  348.         return(FALSE);
  349.         }
  350.  
  351. /***************************************************************/
  352.  
  353. int     int24handler(int errval, int ax, int bp, int si)
  354.  
  355.         {
  356.         char    msg[25];
  357.         int     drive;
  358.  
  359.         if (ax < 0)
  360.             {
  361.             bdosptr(0x09, "\nDevice I/O error has occurred.\n$", 0);
  362.             bdosptr(0x09, "Attempting to recover....\n$", 0);
  363.             hardretn(-1);
  364.             }
  365.  
  366.         drive = (ax & 0x00FF);
  367.         sprintf(msg, "I/O error on disk drive %c. \n$", 'A' + drive);
  368.         bdosptr(0x09, msg, 0);
  369.         bdosptr(0x09, "Attempting to recover....\n$", 0);
  370.         hardretn(-1);
  371.         }
  372.  
  373. /***************************************************************/
  374.  
  375.  
  376.